home *** CD-ROM | disk | FTP | other *** search
/ Scene 96 / Scene 96 International Edition (Zyklop Software) (Disc 2) (1997).iso / misc / coding / midas060 / src / midas.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-16  |  22.4 KB  |  700 lines
  1. /*      MIDAS.C
  2.  *
  3.  * Simplified MIDAS Sound System API
  4.  *
  5.  * $Id: midas.c,v 1.11 1997/01/16 18:41:59 pekangas Exp $
  6.  *
  7.  * Copyright 1996,1997 Housemarque Inc.
  8.  *
  9.  * This file is part of the MIDAS Sound System, and may only be
  10.  * used, modified and distributed under the terms of the MIDAS
  11.  * Sound System license, LICENSE.TXT. By continuing to use,
  12.  * modify or distribute this file you indicate that you have
  13.  * read the license and understand and accept it fully.
  14. */
  15.  
  16. #include <stdio.h>
  17. #include <stdlib.h>
  18. #include <string.h>
  19. #include "midas.h"
  20.  
  21. RCSID(const char *midas_rcsid = "$Id: midas.c,v 1.11 1997/01/16 18:41:59 pekangas Exp $";)
  22.  
  23.  
  24. //#define NOTIMER
  25.  
  26. #define puts(x)
  27.  
  28.  
  29.  
  30. /****************************************************************************\
  31. *      Global variables:
  32. \****************************************************************************/
  33.  
  34. SoundDevice     *midasSD;               /* current Sound Device */
  35.  
  36. #ifdef __WIN32__
  37. SoundDevice     *midasSoundDevices[NUMSDEVICES] =
  38.     { &WinWave,
  39.       &MixNoSound };
  40. #else
  41. #ifdef __LINUX__
  42. SoundDevice     *midasSoundDevices[NUMSDEVICES] =
  43.     { &OSS };
  44. #else
  45. SoundDevice     *midasSoundDevices[NUMSDEVICES] =
  46.     {
  47.       &GUS,
  48.       &GDC,
  49.       &PAS,
  50.       &WSS,
  51.       &SB,
  52.       &NoSound };
  53. #endif
  54. #endif
  55.  
  56. gmpPlayHandle   midasPlayHandle;        /* Generic Module Player playing
  57.                                            handle */
  58.  
  59. int             midasDisableEMS;        /* 1 if EMS usage is disabled
  60.                                            (default 0) */
  61. int             midasSDNumber;          /* Sound Device number (-1 for
  62.                                            autodetect, default -1) */
  63. int             midasSDPort;            /* Sound Device I/O port number
  64.                                            (-1 for autodetect or SD default,
  65.                                            default -1) */
  66. int             midasSDIRQ;             /* Sound Device IRQ number (-1 for
  67.                                            autodetect or SD default,
  68.                                            default -1) */
  69. int             midasSDDMA;             /* Sound Device DMA channel number
  70.                                            (-1 for autodetect or SD default,
  71.                                            default -1) */
  72. int             midasSDCard;            /* Sound Device sound card type
  73.                                            (-1 for autodetect or SD default,
  74.                                            default -1) */
  75. unsigned        midasMixRate;           /* Sound Device mixing rate */
  76. unsigned        midasOutputMode;        /* Sound Device output mode force
  77.                                            bits, default 0 (SD default) */
  78. int             midasAmplification;     /* Forced amplification level or -1
  79.                                            for SD default (default -1) */
  80. int             midasChannels;          /* number of channels open or 0 if no
  81.                                            channels have been opened using
  82.                                            midasOpenChannels() */
  83. int             midasPlayerNum;         /* timer music player number */
  84.  
  85. int             midasEMSInit;           /* is EMS heap manager initialized? */
  86. int             midasTMRInit;           /* is TempoTimer initialized? */
  87. int             midasTMRPlay;           /* is sound being played with timer?*/
  88. int             midasSDInit;            /* is Sound Device initialized? */
  89. int             midasSDChans;           /* are Sound Device channels open? */
  90. int             midasGMPInit;           /* is GMP initialized? */
  91. int             midasGMPPlay;           /* is GMP playing? */
  92. int             midasTMRMusic;          /* is music being player with timer?*/
  93.  
  94. void (CALLING *midasErrorExit)(char *msg);      /* error exit function */
  95.  
  96.  
  97.     /* Channel numbers used with gmpPlaySong(): */
  98. static unsigned midasSDChannels[32] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
  99.     12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
  100.     30, 31 };
  101.  
  102. static char     errmsg[90];
  103. static int      dResult;
  104.  
  105.  
  106.  
  107.  
  108. /****************************************************************************\
  109. *
  110. * Function:     void midasError(int errNum)
  111. *
  112. * Description:  Prints a MIDAS error message to stderr and exits to DOS
  113. *
  114. * Input:        int errNum              MIDAS error code
  115. *
  116. \****************************************************************************/
  117.  
  118. void CALLING midasError(int errNum)
  119. {
  120.     midasClose();                       /* uninitialize MIDAS Sound System */
  121.     mStrCopy(&errmsg[0], "MIDAS Error: ");
  122.     mStrAppend(&errmsg[0], errorMsg[errNum]);
  123.     midasErrorExit(&errmsg[0]);         /* print error message */
  124. }
  125.  
  126.  
  127.  
  128.  
  129. /****************************************************************************\
  130. *
  131. * Function:     void midasUninitError(int errNum)
  132. *
  133. * Description:  Prints an error message to stderr and exits to DOS without
  134. *               uninitializing MIDAS. This function should only be used
  135. *               from midasClose();
  136. *
  137. * Input:        int errNum              MIDAS error code
  138. *
  139. \****************************************************************************/
  140.  
  141. void CALLING midasUninitError(int errNum)
  142. {
  143.     mStrCopy(&errmsg[0], "FATAL MIDAS uninitialization failure: ");
  144.     mStrAppend(&errmsg[0], errorMsg[errNum]);
  145.     midasErrorExit(&errmsg[0]);         /* print error message */
  146. }
  147.  
  148.  
  149.  
  150.  
  151. /****************************************************************************\
  152. *
  153. * Function:     void midasDetectSD(void)
  154. *
  155. * Description:  Attempts to detect a Sound Device. Sets the global variable
  156. *               midasSD to point to the detected Sound Device or NULL if no
  157. *               Sound Device was detected
  158. *
  159. \****************************************************************************/
  160.  
  161. void CALLING midasDetectSD(void)
  162. {
  163.     int         dsd;
  164.     int         error;
  165.  
  166.     midasSD = NULL;                     /* no Sound Device detected yet */
  167.     midasSDNumber = -1;
  168.     dsd = 0;                            /* start from first Sound Device */
  169.  
  170.     /* search through Sound Devices until a Sound Device is detected: */
  171.     while ( (midasSD == NULL) && (dsd < NUMSDEVICES) )
  172.     {
  173.         /* attempt to detect current SD: */
  174.         if ( (error = (*midasSoundDevices[dsd]->Detect)(&dResult)) != OK )
  175.             midasError(error);
  176.         if ( dResult == 1 )
  177.         {
  178.             midasSDNumber = dsd;        /* Sound Device detected */
  179.             /* point midasSD to this Sound Device: */
  180.             midasSD = midasSoundDevices[dsd];
  181.         }
  182.         dsd++;                          /* try next Sound Device */
  183.     }
  184. }
  185.  
  186.  
  187.  
  188.  
  189. /****************************************************************************\
  190. *
  191. * Function:     void midasInit(void);
  192. *
  193. * Description:  Initializes MIDAS Sound System
  194. *
  195. \****************************************************************************/
  196.  
  197. void CALLING midasInit(void)
  198. {
  199.     int         error;
  200.  
  201. #ifndef NOEMS
  202.     if ( !midasDisableEMS )             /* is EMS usage disabled? */
  203.     {
  204.         /* Initialize EMS Heap Manager: */
  205.         if ( (error = emsInit(&midasEMSInit)) != OK )
  206.             midasError(error);
  207.  
  208.         /* was EMS Heap Manager initialized? */
  209.         if ( midasEMSInit == 1 )
  210.         {
  211.             mUseEMS = 1;                /* yes, use EMS memory */
  212.         }
  213.         else
  214.         {
  215.             mUseEMS = 0;                /* no, do not use EMS memory */
  216.         }
  217.     }
  218.     else
  219. #endif
  220.     {
  221.         midasEMSInit = 0;
  222.         mUseEMS = 0;                    /* EMS disabled - do not use it */
  223.     }
  224.  
  225.  
  226.  
  227.     if ( midasSDNumber == -1 )      /* has a Sound Device been selected? */
  228.     {
  229.         midasDetectSD();            /* attempt to detect Sound Device */
  230.         if ( midasSD == NULL )
  231.             midasError(errSDFailure);
  232.     }
  233.     else
  234.     {
  235.         /* use selected Sound Device: */
  236.         midasSD = midasSoundDevices[midasSDNumber];
  237.  
  238.         /* Sound Device number was forced, but if no I/O port, IRQ, DMA or
  239.            sound card type has been set, try to autodetect the values for this
  240.            Sound Device. If detection fails, use default values: */
  241.  
  242.         if ( (midasSDPort == -1) && (midasSDIRQ == -1) &&
  243.             (midasSDDMA == -1) && (midasSDCard == -1) )
  244.             if ( (error = midasSD->Detect(&dResult)) != OK )
  245.                 midasError(error);
  246.     }
  247.  
  248.     if ( midasSDPort != -1 )            /* has an I/O port been selected? */
  249.         midasSD->port = midasSDPort;    /* if yes, set it to Sound Device */
  250.     if ( midasSDIRQ != -1 )             /* SD IRQ number? */
  251.         midasSD->IRQ = midasSDIRQ;      /* if yes, set it to Sound Device */
  252.     if ( midasSDDMA != -1 )             /* SD DMA channel number? */
  253.         midasSD->DMA = midasSDDMA;
  254.     if ( midasSDCard != -1 )            /* sound card type? */
  255.         midasSD->cardType = midasSDCard;
  256.  
  257. #ifndef NOTIMER
  258.     /* initialize TempoTimer: */
  259.     if ( (error = tmrInit()) != OK )
  260.         midasError(error);
  261.  
  262.     midasTMRInit = 1;                 /* TempoTimer initialized */
  263. #endif
  264.  
  265.     /* initialize Sound Device: */
  266.     if ( (error = midasSD->Init(midasMixRate, midasOutputMode)) != OK )
  267.         midasError(error);
  268.  
  269.     midasSDInit = 1;                  /* Sound Device initialized */
  270.  
  271. #ifndef NOTIMER
  272.     /* start playing sound using the timer: */
  273.     if ( (error = tmrPlaySD(midasSD)) != OK )
  274.         midasError(error);
  275.     midasTMRPlay = 1;
  276. #endif
  277.  
  278.     /* Initialize Generic Module Player: */
  279.     if ( (error = gmpInit(midasSD)) != OK )
  280.         midasError(error);
  281.     midasGMPInit = 1;
  282. }
  283.  
  284.  
  285.  
  286.  
  287. /****************************************************************************\
  288. *
  289. * Function:     void midasClose(void)
  290. *
  291. * Description:  Uninitializes MIDAS Sound System
  292. *
  293. \****************************************************************************/
  294.  
  295. void CALLING midasClose(void)
  296. {
  297.     int         error;
  298.  
  299. #ifndef NOTIMER
  300.     /* if music is being played with timer, stop it: */
  301.     if ( midasTMRMusic )
  302.     {
  303.         if ( (error = gmpSetUpdRateFunct(NULL)) != OK )
  304.             midasUninitError(error);
  305.         if ( (error = tmrStopMusic(midasPlayerNum)) != OK )
  306.             midasUninitError(error);
  307.         midasTMRMusic = 0;
  308.     }
  309. #endif
  310.  
  311.     /* If music is being played, stop it: */
  312.     if ( midasGMPPlay )
  313.     {
  314.         if ( (error = gmpStopSong(midasPlayHandle)) != OK )
  315.             midasUninitError(error);
  316.         midasGMPPlay = 0;
  317.     }
  318.  
  319.     /* If Generic Module Player has been initialized, uninitialize it: */
  320.     if ( midasGMPInit )
  321.     {
  322.         if ( (error = gmpClose()) != OK )
  323.             midasUninitError(error);
  324.         midasGMPInit = 0;
  325.     }
  326.  
  327.     /* if Sound Device channels are open, close them: */
  328.     if ( midasSDChans )
  329.     {
  330.         if ( (error = midasSD->CloseChannels()) != OK )
  331.             midasUninitError(error);
  332.         midasSDChans = 0;
  333.         midasChannels = 0;
  334.     }
  335.  
  336. #ifndef NOTIMER
  337.     /* if sound is being played, stop it: */
  338.     if ( midasTMRPlay )
  339.     {
  340.         if ( (error = tmrStopSD()) != OK )
  341.             midasUninitError(error);
  342.         midasTMRPlay = 0;
  343.     }
  344. #endif
  345.  
  346.     /* if Sound Device is initialized, uninitialize it: */
  347.     if ( midasSDInit )
  348.     {
  349.         if ( (error = midasSD->Close()) != OK )
  350.             midasUninitError(error);
  351.         midasSDInit = 0;
  352.         midasSD = NULL;
  353.     }
  354.  
  355. #ifndef NOTIMER
  356.     /* if TempoTimer is initialized, uninitialize it: */
  357.     if ( midasTMRInit )
  358.     {
  359.         if ( (error = tmrClose()) != OK )
  360.             midasUninitError(error);
  361.         midasTMRInit = 0;
  362.     }
  363. #endif
  364.  
  365. #ifndef NOEMS
  366.     /* if EMS Heap Manager is initialized, uninitialize it: */
  367.     if ( midasEMSInit )
  368.     {
  369.         if ( (error = emsClose()) != OK )
  370.             midasUninitError(error);
  371.         midasEMSInit = 0;
  372.     }
  373. #endif
  374. }
  375.  
  376.  
  377.  
  378.  
  379. /****************************************************************************\
  380. *
  381. * Function:     void midasSetDefaults(void)
  382. *
  383. * Description:  Initializes MIDAS Sound System variables to their default
  384. *               states. MUST be the first MIDAS function called.
  385. *
  386. \****************************************************************************/
  387.  
  388. void CALLING midasSetDefaults(void)
  389. {
  390.     midasEMSInit = 0;                   /* EMS heap manager is not
  391.                                            initialized yet */
  392.     midasTMRInit = 0;                   /* TempoTimer is not initialized */
  393.     midasTMRPlay = 0;                   /* Sound is not being played */
  394.     midasSDInit = 0;                    /* Sound Device is not initialized */
  395.     midasSDChans = 0;                   /* Sound Device channels are not
  396.                                            open */
  397.     midasGMPInit = 0;                   /* GMP is not initialized */
  398.     midasGMPPlay = 0;                   /* GMP is not playing */
  399.     midasTMRMusic = 0;                  /* Music is not being played with
  400.                                            timer */
  401.     midasChannels = 0;                  /* No channels opened */
  402.  
  403.     midasDisableEMS = 0;                /* do not disable EMS usage */
  404.     midasSDNumber = -1;                 /* no Sound Device forced */
  405.     midasSDPort = -1;                   /* no I/O port forced */
  406.     midasSDIRQ = -1;                    /* no IRQ number forced */
  407.     midasSDDMA = -1;                    /* no DMA channel number forced */
  408.     midasSDCard = -1;                   /* no sound card type forced */
  409.     midasOutputMode = 0;                /* no output mode forced */
  410.     midasMixRate = 44100;               /* attempt to use 44100Hz mixing
  411.                                            rate */
  412.     midasAmplification = -1;            /* use default amplification level */
  413.  
  414.     mEnableSurround = 0;
  415.  
  416.     midasErrorExit = &errErrorExit;
  417.  
  418.     midasSD = NULL;                     /* point midasSD and midasMP to */
  419.  
  420.     /* Set up buffer length. For multitasking operating systems we will use
  421.        much longer buffer to eliminate breaks in sound under all
  422.        circumstances. Also note that no DOS Sound Devices actually use
  423.        mBufferBlocks: */
  424.  
  425. #if defined(__WIN32__) || defined(__LINUX__)
  426.     mBufferLength = 500;                /* 500ms buffer */
  427.     mBufferBlocks = 16;                 /* in 16 blocks */
  428. #else
  429.     mBufferLength = 40;                 /* 40ms buffer */
  430.     mBufferBlocks = 8;                  /* in 8 blocks (ha) */
  431. #endif
  432.     mDefaultFramerate = 7000;           /* default frame rate 70Hz */
  433.     mSyncScreen = 1;                    /* try to synchronize to screen by
  434.                                            default */
  435. }
  436.  
  437.  
  438.  
  439.  
  440. /****************************************************************************\
  441. *
  442. * Function:     void midasOpenChannels(int numChans);
  443. *
  444. * Description:  Opens Sound Device channels for sound and music output.
  445. *
  446. * Input:        int numChans            Number of channels to open
  447. *
  448. * Notes:        Channels opened with this function can be used for sound
  449. *               playing, and modules played with midasPlayModule() will be
  450. *               played through the last of these channels. This function is
  451. *               provided so that the same number of channels can be open
  452. *               the whole time throughout the execution of the program,
  453. *               keeping the volume level constant. Note that you must ensure
  454. *               that you open enough channels for all modules, otherwise
  455. *               midasPlayModule() will fail.
  456. *
  457. \****************************************************************************/
  458.  
  459. void CALLING midasOpenChannels(int numChans)
  460. {
  461.     int         error;
  462.  
  463.     midasChannels = numChans;
  464.  
  465.     /* open Sound Device channels: */
  466.     if ( (error = midasSD->OpenChannels(numChans)) != OK )
  467.         midasError(error);
  468.     midasSDChans = 1;
  469.  
  470.     /* set amplification level if forced: */
  471.     if ( midasAmplification != -1 )
  472.     {
  473.         if ( (error = midasSD->SetAmplification(midasAmplification)) != OK )
  474.             midasError(error);
  475.     }
  476. }
  477.  
  478.  
  479.  
  480.  
  481. /****************************************************************************\
  482. *
  483. * Function:     void midasCloseChannels(void);
  484. *
  485. * Description:  Closes Sound Device channels opened with midasOpenChannels().
  486. *               Do NOT call this function unless you have opened the sound
  487. *               channels used yourself with midasOpenChannels().
  488. *
  489. \****************************************************************************/
  490.  
  491. void CALLING midasCloseChannels(void)
  492. {
  493.     int         error;
  494.  
  495.     /* Close Sound Device channels: */
  496.     if ( (error = midasSD->CloseChannels()) != OK )
  497.         midasError(error);
  498.     midasSDChans = 0;
  499.     midasChannels = 0;
  500. }
  501.  
  502.  
  503.  
  504.  
  505. /****************************************************************************\
  506. *
  507. * Function:     midasPlayModule(gmpModule *module, int numEffectChns)
  508. *
  509. * Description:  Starts playing a Generic Module Player module loaded to memory
  510. *
  511. * Input:        gmpModule *module       Pointer to loaded module structure
  512. *               int numEffectChns       Number of channels to open for sound
  513. *                                       effects. Ignored if sound channels
  514. *                                       have already been opened with
  515. *                                       midasOpenChannels().
  516. *
  517. * Returns:      Pointer to module structure. This function can not fail,
  518. *               as it will call midasError() to handle all error cases.
  519. *
  520. * Notes:        The Sound Device channels available for sound effects are the
  521. *               _first_ numEffectChns channels. So, for example, if you use
  522. *               midasPlayModule(module, 3), you can use channels 0-2 for sound
  523. *               effects. If you already have opened channels with
  524. *               midasOpenChannels(), the module will be played with the last
  525. *               possible channels, so that the first channels will be
  526. *               available for sound effects. Note that if not enough channels
  527. *               are open this function will fail.
  528. *
  529. \****************************************************************************/
  530.  
  531. void CALLING midasPlayModule(gmpModule *module, int numEffectChns)
  532. {
  533.     short       numChans;
  534.     int         error;
  535.     int         firstChannel;
  536.  
  537.     numChans = module->numChannels;
  538.  
  539.     /* Open Sound Device channels if not already open: */
  540.     if ( midasChannels == 0 )
  541.     {
  542.         if ( (error = midasSD->OpenChannels(numChans + numEffectChns)) != OK )
  543.             midasError(error);
  544.         midasSDChans = 1;
  545.         firstChannel = numEffectChns;
  546.  
  547.         /* set amplification level if forced: */
  548.         if ( midasAmplification != -1 )
  549.         {
  550.             if ( (error = midasSD->SetAmplification(midasAmplification)) != OK )
  551.                 midasError(error);
  552.         }
  553.     }
  554.     else
  555.     {
  556.         if ( midasChannels < numChans )
  557.             midasError(errNoChannels);
  558.         firstChannel = midasChannels - numChans;
  559.     }
  560.  
  561.     /* Start playing the whole song in the module using the last Sound Device
  562.        channels: */
  563.     if ( (error = gmpPlaySong(module, -1, -1, -1, -1,
  564.         &midasSDChannels[firstChannel], &midasPlayHandle)) != OK )
  565.         midasError(error);
  566.     midasGMPPlay = 1;
  567.  
  568. #ifndef NOTIMER
  569.     /* Start playing using the timer: */
  570.     if ( (error = tmrPlayMusic(&gmpPlay, &midasPlayerNum)) != OK )
  571.         midasError(error);
  572.     if ( (error = gmpSetUpdRateFunct(&tmrSetUpdRate)) != OK )
  573.         midasError(error);
  574.  
  575.     midasTMRMusic = 1;
  576. #endif
  577. }
  578.  
  579.  
  580.  
  581.  
  582. /****************************************************************************\
  583. *
  584. * Function:     void midasStopModule(gmpModule *module)
  585. *
  586. * Input:        gmpModule *module       the module which is being played
  587. *
  588. * Description:  Stops playing a module and uninitializes the Module Player.
  589. *               If sound channels were NOT opened through midasOpenChannels(),
  590. *               but by letting midasPlayModule() open them, they will be
  591. *               closed. Sound channels opened with midasOpenChannels() are NOT
  592. *               closed and must be closed separately.
  593. *
  594. \****************************************************************************/
  595.  
  596. void CALLING midasStopModule(gmpModule *module)
  597. {
  598.     int         error, i;
  599.  
  600. #ifndef NOTIMER
  601.     puts("gmpSetUpdRateFunct");
  602.     /* Stop playing music with timer: */
  603.     if ( (error = gmpSetUpdRateFunct(NULL)) != OK )
  604.         midasError(error);
  605.     puts("tmrStopMusic");
  606.     if ( (error = tmrStopMusic(midasPlayerNum)) != OK )
  607.         midasError(error);
  608.  
  609.     midasTMRMusic = 0;
  610. #endif
  611.     puts("gmpStopSong");
  612.     /* Stop playing the module: */
  613.     if ( (error = gmpStopSong(midasPlayHandle)) != OK )
  614.         midasError(error);
  615.     midasGMPPlay = 0;
  616.     midasPlayHandle = NULL;
  617.  
  618.     puts("CloseChannels");
  619.     /* If Sound Device channels were not opened with midasOpenChannels(),
  620.        close them: */
  621.     if ( midasChannels == 0 )
  622.     {
  623.         if ( (error = midasSD->CloseChannels()) != OK )
  624.             midasError(error);
  625.         midasSDChans = 0;
  626.     }
  627.     else
  628.     {
  629.         /* Sound Device channels were originally opened with
  630.            midasOpenChannels(). Now stop sounds from the channels used by
  631.            the Module Player: */
  632.         for ( i = (midasChannels - module->numChannels); i < midasChannels;
  633.             i++ )
  634.         {
  635.             if ( (error = midasSD->StopSound(i)) != OK )
  636.                 midasError(error);
  637.             if ( (error = midasSD->SetVolume(i, 0)) != OK )
  638.                 midasError(error);
  639.         }
  640.     }
  641. }
  642.  
  643.  
  644.  
  645.  
  646. /****************************************************************************\
  647. *
  648. * Function:     void midasSetErrorExit(void (CALLING *errorExit)(char *msg))
  649. *
  650. * Description:  Sets error exit function.
  651. *
  652. * Input:        void (CALLING *errorExit)() Pointer to the function that will
  653. *                                           be called to exit the program with
  654. *                                           an error message.
  655. *
  656. \****************************************************************************/
  657.  
  658. void midasSetErrorExit(void (CALLING *errorExit)(char *msg))
  659. {
  660.     midasErrorExit = errorExit;
  661. }
  662.  
  663.  
  664. /*
  665.  * $Log: midas.c,v $
  666.  * Revision 1.11  1997/01/16 18:41:59  pekangas
  667.  * Changed copyright messages to Housemarque
  668.  *
  669.  * Revision 1.10  1996/09/21 16:38:00  jpaana
  670.  * Changed uss to oss
  671.  *
  672.  * Revision 1.9  1996/07/29 19:36:18  pekangas
  673.  * Added MixNoSound Sound Device for Win32
  674.  *
  675.  * Revision 1.8  1996/07/16 20:05:01  pekangas
  676.  * Fixed buffer size with Visual C
  677.  *
  678.  * Revision 1.7  1996/07/13 20:32:07  pekangas
  679.  * Fixed Sound Device pointers with Visual C
  680.  *
  681.  * Revision 1.6  1996/07/13 19:42:21  pekangas
  682.  * Eliminated Visual C warnings
  683.  *
  684.  * Revision 1.5  1996/07/13 18:18:33  pekangas
  685.  * Fixed to compile with Visual C
  686.  *
  687.  * Revision 1.4  1996/06/05 19:40:35  jpaana
  688.  * Changed usswave to uss
  689.  *
  690.  * Revision 1.3  1996/05/25 09:33:10  pekangas
  691.  * Added mBufferLength and mBufferBlocks initialization to midasSetDefaults()
  692.  *
  693.  * Revision 1.2  1996/05/24 16:20:36  jpaana
  694.  * Added USSWave device and fixed Linux support
  695.  *
  696.  * Revision 1.1  1996/05/22 20:49:33  pekangas
  697.  * Initial revision
  698.  *
  699. */
  700.